// 版权所有2011 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package types2

// 一个类型代表一种Go。
// 所有类型都实现类型接口。
type Type interface {
	// subground返回类型的基础类型。
	Underlying() Type

	// String返回类型的字符串表示形式。
	String() string
}

// under返回真正的扩展基础类型。
// 如果不存在，则结果为Typ[Invalid]。
// under只能在已知类型的情况下调用
// 才能完全设置。
func under(t Type) Type {
	if t, _ := t.(*Named); t != nil {
		return t.under()
	}
	return t.Underlying()
}

// 如果t不是类型参数，则coreType返回基础类型。
// 如果t是一个类型参数，coreType将返回其类型集中所有类型的单个基础
// 类型（如果存在），否则返回nil。如果
// 类型集仅包含不受限制和受限制的通道类型（使用
// 相同的元素类型），则如果限制始终相同，则单个基础类型为受限制的
// 通道类型，否则为零。
func coreType(t Type) Type {
	tpar, _ := t.(*TypeParam)
	if tpar == nil {
		return under(t)
	}

	var su Type
	if tpar.underIs(func(u Type) bool {
		if u == nil {
			return false
		}
		if su != nil {
			u = match(su, u)
			if u == nil {
				return false
			}
		}
		// su==nil | | match（su，u）！=nil 
		su = u
		return true
	}) {
		return su
	}
	return nil
}

// coreString类似于coreType，但也认为[]字节
// 和字符串相同。在本例中，如果成功，并且我们看到
// 一个字符串，则结果是类型（可能是非类型化的）字符串。
func coreString(t Type) Type {
	tpar, _ := t.(*TypeParam)
	if tpar == nil {
		return under(t) // 字符串或非类型字符串
	}

	var su Type
	hasString := false
	if tpar.underIs(func(u Type) bool {
		if u == nil {
			return false
		}
		if isString(u) {
			u = NewSlice(universeByte)
			hasString = true
		}
		if su != nil {
			u = match(su, u)
			if u == nil {
				return false
			}
		}
		// su==nil | |匹配（su，u）！=nil 
		su = u
		return true
	}) {
		if hasString {
			return Typ[String]
		}
		return su
	}
	return nil
}

// 如果x和y相同，则match返回x。
// 如果x和y是相同的通道，但对于它们的方向
// 并且其中一个是不受限制的，则match返回通道
// 和受限制的方向。
// 在所有其他情况下，match返回零。
func match(x, y Type) Type {
	// 常见情况：我们没有频道。
	if Identical(x, y) {
		return x
	}

	// 我们可能只有方向不同的频道。
	if x, _ := x.(*Chan); x != nil {
		if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) {
			// 我们的频道只有方向不同。
			// 如果有不受限制的频道，请选择受限制的频道。
			switch {
			case x.dir == SendRecv:
				return y
			case y.dir == SendRecv:
				return x
			}
		}
	}

	// 类型不同
	return nil
}
